The method, and system of our invention relate to client server systems, and especially to development tools, methods and systems that build upon functions, routines, subroutines, subroutine calls, or object oriented programming.
Programming paradigms built upon such concepts as functions and function calls, subroutines and subroutine calls, global variables and local variables, and object orientation are characterized by such features as xe2x80x9creusable codexe2x80x9d and xe2x80x9cinheritance.xe2x80x9d
In older languages, such as FORTRAN and BASIC, reusability and inheritance were obtained through crafting of functions, routines, and subroutines that were called through global variables in a main program. Subsequently, this has evolved into object oriented programming in such languages as C++ and Java and is built upon a programming paradigm foundation of objects, functions, and class data types. An xe2x80x9cobjectxe2x80x9d is a variable that has xe2x80x9cfunctionsxe2x80x9d associated with it. These functions are called xe2x80x9cmember functions.xe2x80x9d A xe2x80x9cclassxe2x80x9d is a data type whose variable are xe2x80x9cobjects.xe2x80x9d The object""s class, that is, the type of the object, determines which member functions the object has.
In a modern, object oriented programming language, such as C++or Java, the mechanism to create objects and member functions is a xe2x80x9cclass.xe2x80x9d Classes can support xe2x80x9cinformation hidingxe2x80x9d which is a critical part of modem program design. In xe2x80x9cinformation hidingxe2x80x9d, one programming team may design, develop, and implement a class, function, routine, or subroutine while another programming team may use the new class, function, routine, or subroutine. It is not necessary for the programmers who use the class, function, routine, or subroutine to know how it is implemented.
To be noted is that xe2x80x9cobject oriented programmingxe2x80x9d uses the terms xe2x80x9cpublicxe2x80x9d and xe2x80x9cprivatexe2x80x9d while the older techniques use the terms xe2x80x9cglobalxe2x80x9d and xe2x80x9clocalxe2x80x9d for the domain of variables.
One aspect of both paradigms is xe2x80x9ccode reusability,xe2x80x9d whether implicitly by the subroutine or function calls of FORTRAN and the like or explicitly by declaring variables in C++ or JAVA.
There is an especially strong need for a development environment, including development tools, and either functions, routines, and subroutines with global and local variables, or base classes, to allow end users to develop business applications customized to their needs and derived from the supplied functions, routines, and subroutines with global and local variables, or base classes.
The method and system of our invention involve an application development environment. The invention is designed to meet the customization needs of demanding sales, marketing, and customer service information system deployments.
One embodiment of our invention is a system for customizing an application program. The system includes a plurality of reusable modules (characterized as xe2x80x9cbasexe2x80x9d modules in object oriented programming literature and as functions, routines and subroutines in other programming paradigms) for incorporation into end-user derived modules (characterized as xe2x80x9cderivedxe2x80x9d in object oriented programming literature). At least one of the reusable modules has a set of variables accessible by an end-user (xe2x80x9cpublicxe2x80x9d in object oriented programming and xe2x80x9cglobalxe2x80x9d in conventional programming) and a set of variables not accessible by the end-user (xe2x80x9cprivatexe2x80x9d in object oriented programming and xe2x80x9clocalxe2x80x9d in conventional programming). When a derived module incorporates a reusable module, the derived module inherits attributes of the reusable module.
A further aspect of our invention is the provision of a graphical editor for modifying and managing software modules, and an object visualization editor for graphically representing relationships between modules and variables within modules. A further aspect of our invention is the provision of one or more applet designer modules for doing one or more of modifying and extending lists, forms, dialogs, and chart user interfaces. The system can also include one or more view designer modules for visually modifying existing views, as well as wizard modules for creating end user created modules. In one embodiment of our invention at least one of the wizard modules provides an enumeration of required end-user entries for an end user module, this being in response to an end-user entry of the type of end-user created module to be created.
A directory or module repository manager may be provided to allow only one end-user to modify a module at one time.
Depending on the underlying source code, the system of the invention may include a compiler or translator for incremental compilation or translation of end user created modules.
In a preferred embodiment the system of our invention includes one or more interfaces for accessing data and rules from external applications.
In still another embodiment, especially useful for spreadsheet or database applications, the system includes database extension modules for extending a database and to capture data from new fields in one or more of application screens, and external sources. In a particularly preferred embodiment, the database extension modules may contain modules for triggering updates to client applications that reflect and incorporate new database extensions, and for reflecting new columns in existing end user created modules.
A further aspect of the system of our invention is the provision of modules for notification of conflicts between new end user created modules and existing modules. These conflict notification modules may be incorporated in the translator or compiler, or in an index to the repository.
A further aspect of our invention is a method for customizing an application program. This method works with the system of the invention, summarized above, and includes the steps of modifying and managing the end user created modules through a graphical editor; and graphically representing relationships between modules and variables within modules.
A further aspect of the method of our invention is doing one or more of modifying and extending lists, forms, dialogs, and chart user interfaces. Another aspect of our invention is visually modifying existing views.
Another aspect of the method of our invention is creating end user created modules using wizard modules. This may include the additional step of providing an enumeration of required end-user entries for an end user created module in response to an end-user entry of the type of end-user derived module to be created.
Yet another aspect of our invention is storing derived (that is, end user created) modules in a derived module repository manager. This is to allow only one end-user to modify a software module at one time.
A still further aspect of our invention is incrementally compiling a derived module.
Another aspect of our invention is accessing data and rules from external software applications through interfaces.
Another aspect of our invention is extending or scaling a database, that is, modifying its metadata and/or schema, to include new fields and capturing data from new fields in one or more of application screens, and external sources. A further aspect of this is triggering updates to client applications that reflect and incorporate new database extension, as well as reflecting new columns in existing end user created modules.
A further aspect of our invention is providing notification of conflicts between end user created modules and existing modules.
The software development method and system of our invention utilize a suite of tools that serve as the bases for xe2x80x9creusabilityxe2x80x9d, whether implicitly or explicitly. This enables developers to rapidly configure all aspects of the underlying application software, including the look-and-feel, behavior, and workflow, without modifying application source code, SQL, or base classes. The sophisticated repository management capabilities of the method and system of our invention allows teams of developers to work efficiently on configuring applications.
The suite of conventional and object oriented development tools includes a business object designer; a Microsoft Visual Basic-like scripting language, a set of business object interfaces, a Database Extension Designer, and an Application Upgrader.
The application upgrader provides an automated process to upgrade the customizations to future product releases thus protecting the investment in customization. The ease, comprehensiveness, scalability, and upgradeability of the customization process help reduce the total lifecycle cost of customizing enterprise applications.
To be noted is the difference between declarative programming and procedural programming. Declarative programming allows developers to control the behavior of a class by merely setting attribute values, that is, set the property color=black, instead of writing a line of code to set the color the color to black. This may be accomplished under either paradigm.
Also to be noted is that the meta-data repository that contains configuration and customization information can serve to separate this configuration and customization data from the application source code. By this expedient, developers and end-users can configure these objects in an intuitive and easy manner that is less prone to error.